package com.xuwang.service.impl;

import com.xuwang.Util.JWTutil;
import com.xuwang.mapper.AdditiveMapper;
import com.xuwang.pojo.Food;
import com.xuwang.mapper.FoodMapper;
import com.xuwang.pojo.FoodRelation;
import org.springframework.stereotype.Service;
import javax.annotation.Resource;
import javax.servlet.http.HttpServletRequest;
import java.sql.ClientInfoStatus;
import java.sql.Timestamp;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * 菜品上报表(Food)表服务实现类
 *
 * @author abaaba
 * @since 2021-09-15 20:31:39
 * @version 1.0
 */
@Service("foodService")
public class FoodServiceImpl {
    @Resource
    private FoodMapper foodMapper;
    @Resource
    private AdditiveMapper additiveMapper;


//    /**
//     * 根据模糊条件查询总个数
//     *
//     * @param name 查询条件
//     * @return 返回查询到的总个数
//     */
//    public Map<String, Object> selectForCount(String name) {
//        Map<String, Object> map = new HashMap<>();
//        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
//        map.put("code", 200);
//        map.put("msg", "查询成功");
//        map.put("data", this.foodMapper.selectForCount(name));
//        return map;
//    }

    /**
     * 查询所有菜品数据
     * @return  返回所有数据
     */
    public Map<String, Object> selectAllFood() {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", this.foodMapper.selectAllFood());
        return map;
    } /**
     * 查询所有菜品数据
     * @return  返回所有数据
     */
    public Map<String, Object> selectAllFoodKind() {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", this.foodMapper.selectAllFoodKind());
        return map;
    }

    /**
     * 通过ID查询单条数据
     *
     * @param id 主键
     * @return 实例对象
     */
    public Map<String, Object> selectById(Integer id) {
        Map<String, Object> map = new HashMap<>();
        // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("code", 200);
        map.put("msg", "查询成功");
        map.put("data", this.foodMapper.selectById(id));
        return map;
    }

    /**
     * 通过实体作为筛选条件查询
     * @param foodName      菜品名称
     * @param foodWarranty  菜品保质期
     * @param markType      制作类型

     * @param action        状态（审核与否）
     * @param isDelete      是否删除
     * @param companyName   公司名字
     * @param address       公司地址
     * @return       查询结果
     */
    public Map<String, Object> selectForPage(int index,int page,
            String foodName, String foodWarranty, String markType, Integer foodKind, String action, String isDelete, String companyName, String address) {
        Map<String, Object> map = new HashMap<>();
        // 获取当前表中的总记录
        String[] split = action.split(",");
        List<String> strings = Arrays.asList(split);
        int tableCount = this.foodMapper.selectForCount(foodName,foodWarranty,markType,foodKind,strings,isDelete,companyName,address);
        // 总页码计算   (总条数 - 1) / 每页显示条数  + 1
        // (100 - 1) / 10 + 1 = 10        (101 - 1) / 10 + 1 = 11      (99 - 1) / 10 + 1 = 10
        int pageCount = (tableCount - 1) / page + 1;
        // 计算每页开始的下标值
        index = (index - 1) * page;
        Integer index1=foodMapper.selectNumberByIndexOrPage(index,foodName,foodWarranty,markType,foodKind,strings,isDelete,companyName,address);
        Integer page1=foodMapper.selectNumberByIndexOrPage(page,foodName,foodWarranty,markType,foodKind,strings,isDelete,companyName,address);
        index=index1==null?0:index1;
        page=page1==null?0:page1;
        List<Food> foods=(this.foodMapper.selectForPage(index,page,foodName,foodWarranty,markType,foodKind,strings,isDelete,companyName,address));
        map.put("code", 0);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "查询成功");
        map.put("pageCount", pageCount);  // 当前总数
        map.put("count", tableCount);     // 总条数
        map.put("data", foods);
        System.out.println(foods.size());
        return map;
    }

    /**
     * 新增数据
     *
     * @param food 实例对象
     * @return 实例对象
     */
    public Map<String, Object> insert(Food food, HttpServletRequest request) {
        // UUID.randomUUID()  返回内容：asd21321-ewrewrew213213-123213zsad-123asdasd这样的形态

        String token = request.getHeader("Authorization");
        String userName = JWTutil.getUserName(token);
//        String userName="菜品人";
        food.setApplyCompanyId(additiveMapper.selectCompanyIdByUsername(userName));
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date());
        food.setCreateTime(Timestamp.valueOf(format));
        this.foodMapper.insert(food);

        Integer id = food.getId();
        for (FoodRelation foodRelation : food.getFoodRelationList()) {
            foodRelation.setFoodId(id);
        }
        foodMapper.insertAllFoodRelation(food.getFoodRelationList());

        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "上报成功");
        return map;
    }

    /**
     * 通过ID查询单条数据
     *
     * @param food 实例对象
     * @return 实例对象
     */
    public Map<String, Object> updateById(Food food,HttpServletRequest request) {
        this.foodMapper.updateIsDeleteById(String.valueOf(food.getId()),1);
        this.insert(food,request);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "更新成功");
        return map;
    }

    /**
     * 通过主键删除数据
     *
     * @param id 主键
     * @return 是否成功
     */
    public Map<String, Object> updateIsDeleteById(String id,int isDelete) {
        this.foodMapper.updateIsDeleteById(id,isDelete);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", isDelete==0?"恢复成功":"删除成功");
        return map;
    }

    /**
     * 通过主键更改审批状态数据
     *
     * @param id 主键
     * @return 是否成功
     */
    public Map<String, Object> updateActionById(String id,Integer action) {
        this.foodMapper.updateActionById(id,action);
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", action==1?"审批通过":"审批拒绝");
        return map;
    }

    /**
     * 批量删除多条数据
     *
     * @param ids 批量主键
     * @return 单条数据
     */
    public Map<String, Object> updateIsDeleteByIds(String ids) {
        String[] split = ids.split(",");
        for (int i = 0; i < split.length; i++) {
            this.foodMapper.updateIsDeleteById(split[i],1);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("code", 200);   // 前端端分离时，前端人员会首先判断code值是否满足200，如果不是200，则提醒用户失败
        map.put("msg", "删除多条成功");
        return map;
    }
}